package com.ruoyi.module.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ruoyi.module.domain.DictBook;
import com.ruoyi.module.domain.DictBookUser;
import com.ruoyi.module.mapper.DictBookMapper;
import com.ruoyi.module.mapper.DictBookUserMapper;
import com.ruoyi.module.service.IDictBookUserService;

/**
 * 词典用户关联Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-10-27
 */
@Service
public class DictBookUserServiceImpl implements IDictBookUserService 
{
    @Autowired
    private DictBookUserMapper dictBookUserMapper;

    @Autowired
    private DictBookMapper dictBookMapper;

    /**
     * 查询词典的授权用户列表
     * 
     * @param bookId 词典ID
     * @return 词典用户关联
     */
    @Override
    public List<DictBookUser> selectDictBookUserListByBookId(String bookId)
    {
        return dictBookUserMapper.selectDictBookUserListByBookId(bookId);
    }

    /**
     * 查询用户的授权词典列表
     * 
     * @param userId 用户ID
     * @return 词典用户关联
     */
    @Override
    public List<DictBookUser> selectDictBookUserListByUserId(Long userId)
    {
        return dictBookUserMapper.selectDictBookUserListByUserId(userId);
    }

    /**
     * 检查用户是否有词典权限
     * 
     * @param bookId 词典ID
     * @param userId 用户ID
     * @return true表示有权限，false表示无权限
     */
    @Override
    public boolean checkUserBookPermission(String bookId, Long userId)
    {
        // admin用户拥有所有权限
        if (userId != null && userId == 1L) {
            return true;
        }
        return dictBookUserMapper.checkUserBookPermission(bookId, userId) > 0;
    }

    /**
     * 为词典批量添加用户
     * 
     * @param bookId 词典ID
     * @param userIds 用户ID数组
     * @param createBy 创建者
     * @return 结果
     */
    @Override
    public int batchInsertDictBookUser(String bookId, Long[] userIds, String createBy)
    {
        return dictBookUserMapper.batchInsertDictBookUser(bookId, userIds, createBy);
    }

    /**
     * 删除词典的指定用户
     * 
     * @param bookId 词典ID
     * @param userIds 用户ID数组
     * @return 结果
     */
    @Override
    public int deleteDictBookUserByBookIdAndUserIds(String bookId, Long[] userIds)
    {
        return dictBookUserMapper.deleteDictBookUserByBookIdAndUserIds(bookId, userIds);
    }

    /**
     * 删除词典的所有用户
     * 
     * @param bookId 词典ID
     * @return 结果
     */
    @Override
    public int deleteDictBookUserByBookId(String bookId)
    {
        return dictBookUserMapper.deleteDictBookUserByBookId(bookId);
    }

    /**
     * 为新用户分配所有免费词典
     * 
     * @param userId 用户ID
     * @return 分配的词典数量
     */
    @Override
    @Transactional
    public int assignFreeDictBooksToUser(Long userId)
    {
        // 查询所有免费词典
        List<DictBook> freeBooks = dictBookMapper.selectFreeDictBooks();
        
        if (freeBooks == null || freeBooks.isEmpty())
        {
            return 0;
        }
        
        // 批量插入用户-词典关联
        List<DictBookUser> userBooks = new ArrayList<>();
        for (DictBook book : freeBooks)
        {
            DictBookUser userBook = new DictBookUser();
            userBook.setBookId(book.getId());
            userBook.setUserId(userId);
            userBook.setCreateBy("system");
            userBooks.add(userBook);
        }
        
        // 调用批量插入方法
        if (!userBooks.isEmpty())
        {
            return dictBookUserMapper.batchInsertDictBookUserList(userBooks);
        }
        
        return 0;
    }
}

